/**
 * N个格子，初始在第1格。在第i格，有Pi的概率到下一格
 * Pi以2的负ki次方的形式给出。 
 * 有 1 - Pi 的概率就停止在第i格
 * 问每一格的停留的概率是多少。还要求将每一格停留的概率从大到小排序，求排名。
 * 
 * 设所有概率相乘记作fenmu。
 * 对第i格，停留的概率依次是：
 *     P[1] * P[2] * P[3] * ... P[i - 1] * (1 - P[i - 1]) * (1 + fenmu + fenmu ^ 2 + fenmu ^ 3 + ...)
 * 即第一次碰到i就停下，转了一圈以后停下，转了二圈以后停下，...
 * 依次计算即可。
 * 计算排名比较麻烦，因为要计算取模之前的。
 * 对任意i、j，不是一般性，假设i < j，只需比较
 * P[1] * P[2] * P[3] * ... P[i - 1] * (1 - P[i])
 * 与
 * P[1] * P[2] * P[3] * ... P[i - 1] * P[i] * ... * P[j - 1] * (1 - P[j])
 * 首先讨论特殊情况：
 * 当 Pi == 1 时，说明一定到下一格，因此停止i的机会为零。
 * 此时，如果 Pj == 1，按照题意，i应该排在前面
 * 否则，必然停留在j的概率必不为零，j应该排在前面
 * 当 Pj == 1 时，同理。
 * 现在只需讨论不特殊的情况即可，可以证明
 *             P[1] * P[2] * P[3] * ... P[i - 1] * (1 - P[i])
 * -------------------------------------------------------------------------- >= 1 恒成立
 *    P[1] * P[2] * P[3] * ... P[i - 1] * P[i] * ... * P[j - 1] * (1 - P[j])
 * 即i必然排在j前面
 *                           (1 - P[i])
 * 原不等式等价于  ------------------------------------ >= 1
 *                P[i] * ... * P[j - 1] * (1 - P[j])
 * 
 * 等价于 (1 - P[i]) >= P[i] * ... * P[j - 1] * (1 - P[j])
 * 对右边进行缩放，只需证明 (1 - P[i]) >= Pi * (1 - P[j]) 成立即可
 * 该不等式等价于 1 - Pi >= Pi - Pi * Pj
 * 等价于 1 - Pi - Pi + PiPj >= 0
 * 注意到题目中 Pi不为1的话，必然就要小于等于 1/2 ，所以最后一个不等式必然成立。
 * 从而可知i必然排在j的前面
 */
#include <bits/stdc++.h>
using namespace std;

#include <bits/extc++.h>
using namespace __gnu_pbds;


using llt = long long;
using Real = double;
using vi = vector<int>;

llt const MOD = 998244353;

llt qpow(llt a, llt n){
    llt r = 1;
    while(n){
        if(n & 1) r = r * a % MOD;
        a = a * a % MOD;
        n >>= 1;
    }
    return r;
}

llt inv(llt a){return qpow(a, MOD-2LL);}

int N;
vector<llt> P;

llt myhash(const vector<llt> & vec){
    llt ans = 0;
    llt k = 0;
    for(auto i : vec){
        ans = (ans + (++k) * i % MOD) % MOD;
    }
    return ans;
}

void proc(){
    auto tmp = accumulate(P.begin(), P.end(), 0LL);
    auto pi = inv(qpow(2LL, tmp));

    auto fenmu = inv((MOD + 1 - pi) % MOD);
    vector<llt> ans(N);
    llt fenzi = 1;
    for(int i=0;i<N;++i){
        auto p = inv(qpow(2, P[i]));
        auto q = (MOD + 1 - p) % MOD;
        ans[i] = fenzi * q % MOD * fenmu % MOD;
        fenzi = fenzi * p % MOD;
    }

    vector<llt> rank(N);
    for(int i=0;i<N;++i) rank[i] = i + 1;
    sort(rank.begin(), rank.end(), [&](int i, int j){
        i -= 1, j -= 1;
        if(0 == P[i]){ // 100%会走，即停到此处的概率为0
            if(0 == P[j]) return i < j; 
            return false; // 停在j的概率肯定比i大
        }
        if(0 == P[j]) return true;
        return i < j;
    });

    cout << myhash(ans) << endl;
    cout << myhash(rank) << endl;
    return;
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("z.txt", "r", stdin);
#endif
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(0);
    cin >> N;
    P.assign(N, {});
    for(auto & i : P) cin >> i;
    proc();
    return 0;
}